<?php

// Evitar que se carge la maye esa de EXCEL
//$bolGNoCargarSpreadsheetExcelWriter = true;
require_once(BaseConfig::LoadClass('reporte.class.php'));

/**
 * Clase que genera graficas y estadisticas de una tabla (o una consulta)
 * 
 * Tambien puede generar reportes (En excel o HTML) para ser desplegados, usando
 * la clase reporte.class.php
 */

class Estadisticas extends Reporte {
  /**
   * Nombre de la clase de los objetos. Dicha clase debe ser extendida de la
   * clase "ABC_Base" para que pueda obtener la informacion acerca de los 
   * nombres de las columnas.
   * 
   * Se podrán incluir varios nombres de clases derivadas de Estadistica en la
   * clase ABC_Base derivada, lo cual colocará una serie de botones para 
   * desplegar las estadisticas, reportes, etc. Estas entradas en ABC_Base 
   * podrán incluir, de manera opcional, un arreglo con opciones.
   *
   * Si esta variable se deja vacia, se pensará que lo que se necesita es una
   * consulta, lo cual tendrá requerimientos especiales.
   * 
   * @var String
   */
  var $strClaseABCBase;
  
  /**
   * Tipo de reporte que será generado:
   * 
   * 0 => Reporte en HTML
   * 1 => Reporte en Excel
   * 2 => Grafica
   * 3 => PDF
   * 
   * @var int
   */
  var $intTipoReporte;
  
  /**
   * Arreglo con informacion de la grafica. Si no se encuentra se utilizará, a
   * lo mas posible, el $arrInfoReporte
   * 
   * @var array
   */
  var $arrInfoGrafica;
  
  /**
   * Arreglo con informacion de agrupacion de la grafica. Si no se encuentra se 
   * utilizará, a lo mas posible, el $arrDifHeader
   * 
   * @var array
   */
  var $arrDifHeaderGrafica;
  
  /**
   * Ancho del div que contiene la grafica. Se puede usar de la manera '100%'
   * 
   * @var string
   */
  var $strAnchoDiv;
  
  /**
   * Alto del div que contiene los datos
   * @var string
   */
  var $strAltoDiv ;
  
  /**
   * Orientacion de la pagina para reportes en PDF
   * P => Portrait
   * L => Landscape
   * 
   * @var string
   */
  var $strOrientacionPDF;
  
  /**
   * Formato de la pagina para PDF (A4, A3, etc.)
   * 
   * @var string
   */
  var $strPageFormatPDF;
  
  function Estadisticas() {
    
  }
  
  function __DoReporteTCPDF($arrReporte) {
    if(!$this->strOrientacionPDF) $this->strOrientacionPDF = "P";
    if(!$this->strPageFormatPDF ) $this->strPageFormatPDF  = "A4";
    
    $oReportePDF = new ReportePDF($this, $arrReporte, $this->strOrientacionPDF, $this->strPageFormatPDF);
    
    return $oReportePDF->DoRender();
  }
  
  function __ArreglarDatosPrevioGrafica() {
    $arrReporte = $this->__ArreglarDatosPrevioMuestreo($this->strOpAgrupar != "");
    
    return $arrReporte;
  }
  
  function __ArrangeArray($arrReporte, $bolHacerTotales = true) {
    if((Variables::GetOption('__OGOrden')) && (Variables::GetOption('__OGOrden') != '__NINGUNA__')) {
      // Ordenar los datos a mostrar
      $arrReporte = Variables::OrdenarPorClaveConservaIndice($arrReporte, Variables::GetOption('__OGOrden'));
      if(Variables::GetOption('__OGTipoOrden') == "DESC") {
        $arrReporte = array_reverse($arrReporte, true);
      }
    }
    return parent::__ArrangeArray($arrReporte, $bolHacerTotales);
  }
  
  function __ObtenerFormaOpcionesGrafica($bolMostrarStacking = true, $bolMostrarAltoAncho = true, $bolMostrarTipoReporte = true, $bolMostrarOrden = true) {
    $arrOpcionesStacking = array();
    $arrOpcionesStacking["normal" ] = "Normal"     ;
    $arrOpcionesStacking["nostack"] = "No estancar";
    $arrOpcionesStacking["percent"] = "Porcentaje" ;
    
    $arrOpcionesAlto = array();
    if($this->strAltoDiv) { $arrOpcionesAlto[$this->strAltoDiv] = $this->strAltoDiv; }
    // Como primera opcion ponemos, de todos modos, la de 700 px
    $arrOpcionesAlto["700px"] = "700px";
    for($i = 300; $i <= 1300; $i += 100) {
      $arrOpcionesAlto["{$i}px"] = "{$i}px";
    }
    
    $arrOpcionesAncho = array();
    if($this->strAnchoDiv) { $arrOpcionesAncho[$this->strAnchoDiv] = $this->strAnchoDiv; }
    $arrOpcionesAncho["100%"] = "100%";
    for($i = 20; $i <= 800; $i += 20) {
      $arrOpcionesAncho["{$i}%"] = "{$i}%";
    }
    
    $arrOpcionesTipoReporte = array();
    $arrOpcionesTipoReporte["normal" ] = "Normal" ;
    $arrOpcionesTipoReporte["excel"  ] = "Excel"  ;
    $arrOpcionesTipoReporte["pdf"    ] = "PDF"    ;
    $arrOpcionesTipoReporte["grafica"] = "Grafica";
    
    $arrOpcionesTipoOrden = array();
    $arrOpcionesTipoOrden["ASC" ] = "Ascendente" ;
    $arrOpcionesTipoOrden["DESC"] = "Descendente";
    
    $arrOpcionesOrden = array();
    $arrOpcionesOrden["__NINGUNA__"] = ":: ORDEN ORIGINAL ::";
    $arrInfoReporte = $this->arrInfoReporte;
    $arrDifHeader   = $this->arrDifHeader  ;
    if(Variables::GetOption('__OGTipoRep') == "grafica") {
      if(is_array($this->arrInfoGrafica     )) { $arrInfoReporte = $this->arrInfoGrafica     ; }
      if(is_array($this->arrDifHeaderGrafica)) { $arrDifHeader   = $this->arrDifHeaderGrafica; }
    }
    foreach($arrInfoReporte as $strClave => $arrInfoClave) {
      if(
        (substr($arrInfoClave["Tipo"], 0, 1) == "I" ) ||
        (substr($arrInfoClave["Tipo"], 0, 1) == "D" ) ||
        (substr($arrInfoClave["Tipo"], 0, 1) == "F" )
      ) {
        
      } else {
        continue;
      }
      $bolIncluido = false;
      if(is_array($arrDifHeader)) {
        foreach($arrDifHeader as $arrInfoDifHeader) {
          if(in_array($strClave, $arrInfoDifHeader)) {
            $bolIncluido = true;
            $arrOpcionesOrden[$strClave] = "{$arrInfoDifHeader[0]} {$arrInfoClave["Nombre"]}";
          }
        }
      }
      if(!$bolIncluido) {
        $arrOpcionesOrden[$strClave] = $arrInfoClave["Nombre"];
      }
    }
    
    $strRes  = "";
    $strRes .= "<hr />";
    $strRes .= "<table>";
    if($bolMostrarStacking) {
      $strRes .= "<tr><td>Stacking:</td><td>" . Variables::GetSelectByArray($arrOpcionesStacking, Variables::GetOption('__OGStacking'), '__OGStacking') . "</td></tr>";
    }
    
    if($bolMostrarAltoAncho) {
      $strRes .= "<tr><td>Alto:</td><td>" . Variables::GetSelectByArray($arrOpcionesAlto , Variables::GetOption('__OGAlto' ), '__OGAlto' ) . "</td></tr>";
      $strRes .= "<tr><td>Ancho:</td><td>" . Variables::GetSelectByArray($arrOpcionesAncho, Variables::GetOption('__OGAncho'), '__OGAncho') . "</td></tr>";
    }
    
    if($bolMostrarTipoReporte) {
      $strRes .= "<tr><td>Tipo de reporte:</td><td>" . Variables::GetSelectByArray($arrOpcionesTipoReporte, Variables::GetOption('__OGTipoRep' ), '__OGTipoRep') . "</td></tr>";
    }
    
    if($bolMostrarOrden) {
      $strRes .= "<tr><td>Orden:</td>";
      $strRes .= "<td>" . Variables::GetSelectByArray($arrOpcionesOrden    , Variables::GetOption('__OGOrden'    ), '__OGOrden'    ) . "</td></tr>";
      $strRes .= "<tr><td>&nbsp;</td><td>" . Variables::GetSelectByArray($arrOpcionesTipoOrden, Variables::GetOption('__OGTipoOrden'), '__OGTipoOrden') . "</td></tr>";
    }
    
    $strRes .= "</table>";
    
    return $strRes;
  }
  
  /**
   * Funcion que obtiene el FORM para mandar a llamar de nuevo la pagina
   * 
   * @param string $strElementosACubrir HTML con los inputs que se cubriran por esta forma
   */
  function __ObtenerFormaParaSubmit($strElementosACubrir) {
    $strRes  = "";
    $strRes .= "<form action='index.php' method='POST'>";
    $strRes .= "<input type='hidden' name='option' value='" . Variables::GetPageOption() . "' />";
    $strRes .= $strElementosACubrir;
    $strRes .= "<input type='submit' value='Generar' />";
    $strRes .= "</form>";
    
    return $strRes;
  }
  
  
  function __ObtenerLlamadaGraficacion($strTipoGrafica, $strSeries, $strCategorias, $strNombreReporte, $strStacking = "") {
    // Div contenedor. Se necesita cambiar el ID de cada grafica para poder mostrar mas de una en una misma pagina
    $strIdDivContenedor = "div_grafica_" + rand(1000, 9999);
    $strRes  = "";
    
    if(Variables::GetOption('__OGAlto'      )) { $this->strAltoDiv  = Variables::GetOption('__OGAlto'    ); }
    if(Variables::GetOption('__OGAncho'     )) { $this->strAnchoDiv = Variables::GetOption('__OGAncho'   ); }
    if($strStacking == "") {
      if(Variables::GetOption('__OGStacking')) { $strStacking       = Variables::GetOption('__OGStacking'); }
    }
    
    $strRes .= "<div id='$strIdDivContenedor' style='width:{$this->strAnchoDiv}; height:{$this->strAltoDiv};'></div>";
    $strRes .= "<script>";
    $strRes .= "MostrarGrafica(";
    $strRes .= "  \"$strTipoGrafica\", ";
    $strRes .= "  \"$strIdDivContenedor\", ";
    $strRes .= "  \"$strSeries\", ";
    $strRes .= "  \"$strCategorias\", ";
    $strRes .= "  \"" . Variables::QuitarElementosASCIIFueraRango($strNombreReporte, true) . "\", ";
    $strRes .= "  \"{$strStacking}\" ";
    $strRes .= ");";
    $strRes .= "</script>";
    
    return $strRes;
  }
  
  function __ArreglarDatosGrafica($arrReporte) {
    $arrCategorias = array();
    $arrValores    = array();
    
    if(!is_array($this->arrInfoGrafica)) {
      $arrInfoUsar = $this->arrInfoReporte;
    } else {
      $arrInfoUsar = $this->arrInfoGrafica;
    }
    
    if(!is_array($this->arrDifHeaderGrafica)) {
      $arrDifHeader = $this->arrDifHeader;
    } else {
      $arrDifHeader = $this->arrDifHeaderGrafica;
    }
    
    foreach($arrReporte as $intNumLin => $arrLinea) {
      if((isset($arrLinea["xTotx"   ])) && ($arrLinea["xTotx"   ] == "1")) continue;
      if((isset($arrLinea["xSubTotx"])) && ($arrLinea["xSubTotx"] == "1")) continue;
//      if(($arrLinea["xSubTotx"] != "1") && ($arrLinea["xTotx"] != "1")) continue;
      
      foreach($arrInfoUsar as $strClave => $arrInfoClave) {
        if(substr($arrInfoClave["Tipo"], 0, 1) == "C") {
          // Creando los nombres de los ejes
          if(!isset($arrCategorias[$intNumLin])) {
            $arrCategorias[$intNumLin] = "";
          }
          $arrCategorias[$intNumLin] .= $arrLinea[$strClave] . " ";
        } else if(
          (substr($arrInfoClave["Tipo"], 0, 1) == "I" ) ||
          (substr($arrInfoClave["Tipo"], 0, 1) == "D" ) ||
          (substr($arrInfoClave["Tipo"], 0, 1) == "F" )
        ) {
          // Numeros que se pueden graficar
          $arrValores[$intNumLin][$strClave]["Nombre"] = $arrInfoClave["Nombre"];
          $arrValores[$intNumLin][$strClave]["Valor" ] = $arrLinea[$strClave];
          if(isset($arrLinea["xURL_{$strClave}"])) {
            $arrValores[$intNumLin][$strClave]["URL" ] = $arrLinea["xURL_{$strClave}"];
          }
          // Ver si se necesita poner un stack diferente
          if(is_array($arrDifHeader)) {
            foreach($arrDifHeader as $intNumDifHeader => $arrInfoDiffHeader) {
              if(in_array($strClave, $arrInfoDiffHeader)) {
                $arrValores[$intNumLin][$strClave]["Stack" ] = $intNumDifHeader;
                $arrValores[$intNumLin][$strClave]["Nombre"] = $arrInfoDiffHeader[0] . " " . $arrInfoClave["Nombre"];
              }
            }
            if(!isset($arrValores[$intNumLin][$strClave]["Stack"])) {
              $arrValores[$intNumLin][$strClave]["Stack" ] = 1;
            }
          } else {
            $arrValores[$intNumLin][$strClave]["Stack" ] = 1;
          }
          
          if(isset($arrInfoClave["Color"]) && ($arrInfoClave["Color"] != "")) {
            $arrValores[$intNumLin][$strClave]["Color"] = $arrInfoClave["Color"];
            if(count($arrDifHeader)) {
//              $arrValores[$intNumLin][$strClave]["Color"] = Variables::BlendColorHex($arrInfoClave["Color"], "#FFFFFF", count($arrDifHeader) + 1, $arrValores[$intNumLin][$strClave]["Stack"]);
            }
          }
        }
      }
    }
    
    return $this->__ManejarDatosPreGrafica(array("Categorias" => $arrCategorias, "Valores" => $arrValores));
  }
  
  function __ManejarDatosPreGrafica($arrDatos) {
    return $arrDatos;
  }
  
  function __ObtenerArreglosVertical($arrReporte) {
    $arrDatos      = $this->__ArreglarDatosGrafica($arrReporte);
    $arrCategorias = $arrDatos["Categorias"];
    $arrValores    = $arrDatos["Valores"   ];
    
    $strCategorias  = "";
    $strCategorias .= "[";
    foreach($arrValores[0] as $arrInfoClave) {
      $strCategorias .= "'" . Variables::QuitarElementosASCIIFueraRango($arrInfoClave["Nombre"], true) . "', ";
    }
    $strCategorias = substr($strCategorias, 0, -2) . "]";
    
    $strSeries  = "";
    $strSeries .= "[";
    foreach($arrCategorias as $intNumLin => $strNomCat) {
      $strSeries .= "{";
      $strSeries .= "name:'" . Variables::QuitarElementosASCIIFueraRango($strNomCat) . "', ";
      $strSeries .= "data:[";
      foreach($arrValores[0] as $strClave => $arrInfoClave) {
        $strSeries .= "{ y: " . ($arrValores[$intNumLin][$strClave]["Valor"] - 0);
        if(isset($arrValores[$intNumLin][$strClave]["URL"])) {
          $strSeries .= ", url: '{$arrValores[$intNumLin][$strClave]["URL"]}'";
        }
        $strSeries .= " }, ";
      }
      $strSeries  = substr($strSeries, 0, -2) . "]";
      $strSeries .= "}, ";
    }
    $strSeries = substr($strSeries, 0, -2) . "]";
    
    return array("Categorias" => $strCategorias, "Series" => $strSeries);
  }
  
  function __ObtenerArreglosHorizontal($arrReporte) {
    $arrDatos      = $this->__ArreglarDatosGrafica($arrReporte);
    $arrCategorias = $arrDatos["Categorias"];
    $arrValores    = $arrDatos["Valores"   ];
    
    $strCategorias  = "";
    $strCategorias .= "[";
    foreach($arrCategorias as $strNomCat) {
      $strCategorias .= "'" . Variables::QuitarElementosASCIIFueraRango($strNomCat, true) . "', ";
    }
    $strCategorias = substr($strCategorias, 0, -2) . "]";
    
    $strSeries  = "";
    $strSeries .= "[";
    foreach($arrValores[0] as $strClave => $arrInfoClave) {
      $strSeries .= "{";
      $strSeries .= "name:'" . Variables::QuitarElementosASCIIFueraRango($arrInfoClave["Nombre"]) . "', ";
      $strSeries .= "stack:" . ($arrInfoClave["Stack"]) . ", ";
      if(isset($arrInfoClave["Color"]) && ($arrInfoClave["Color"] != "")) {
        $strSeries .= "color:'" . ($arrInfoClave["Color"]) . "', ";
      }
      $strSeries .= "data:[";
      foreach($arrCategorias as $intNumLin => $arrLinea) {
        $strSeries .= "{ y: " . ($arrValores[$intNumLin][$strClave]["Valor"] - 0);
        if(isset($arrValores[$intNumLin][$strClave]["URL"])) {
          $strSeries .= ", url: '{$arrValores[$intNumLin][$strClave]["URL"]}'";
        }
        $strSeries .= " }, ";
      }
      $strSeries  = substr($strSeries, 0, -2) . "]";
      $strSeries .= "}, ";
    }
    $strSeries = substr($strSeries, 0, -2) . "]";
    
    return array("Categorias" => $strCategorias, "Series" => $strSeries);
  }
  
  function __ObtenerArreglosDoublePieHorizontal($arrReporte, $bolConservarColores = false) {
    $arrDatos      = $this->__ArreglarDatosGrafica($arrReporte);
    $arrCategorias = $arrDatos["Categorias"];
    $arrValores    = $arrDatos["Valores"   ];
    
    $strSeries1 = "[";
    $strSeries2 = "[";
    
    if(is_array($this->arrInfoGrafica)) {
      $arrInfoG = $this->arrInfoGrafica;
    } else {
      $arrInfoG = $this->arrInfoReporte;
    }
    
    // Empezamos a recorrer los datos
    foreach($arrCategorias as $intIndiceCat => $strNombreCat) {
      // Necesitamos al final el total, por lo que lo revertimos a cero
      $fltTotalCategoria = 0;
      // Recorremos cada uno de los datos de esa categoria
      foreach($arrValores[$intIndiceCat] as $strNombreCol => $arrInfoValorCat) {
        $strSeries2 .= "{";
        if($bolConservarColores) {
          if(isset($arrInfoG[$strNombreCol]["Color"]) && ($arrInfoG[$strNombreCol]["Color"] != "")) {
            $strSeries2 .= "color: '{$arrInfoG[$strNombreCol]["Color"]}', ";
          } else {
            $strSeries2 .= "color: colors[$intIndiceCat % 10], ";
          }
        } else {
          $strSeries2 .= "color: colors[$intIndiceCat % 10], ";
        }
        $strSeries2 .= "name:'{$arrInfoValorCat["Nombre"]}', ";
        $strSeries2 .= "y: " . ($arrInfoValorCat["Valor"] - 0);
        $strSeries2 .= "}, ";
        
        $fltTotalCategoria += $arrInfoValorCat["Valor"];
      }
      
      $strSeries1 .= "{";
      $strSeries1 .= "color: colors[$intIndiceCat % 10], ";
      $strSeries1 .= "name:'$strNombreCat', ";
      $strSeries1 .= "y: $fltTotalCategoria";
      $strSeries1 .= "}, ";
      
    }
    
    $strSeries1 = substr($strSeries1, 0, -2) . "]";
    $strSeries2 = substr($strSeries2, 0, -2) . "]";
    
    return array("Series1" => $strSeries1, "Series2" => $strSeries2);
  }
  
  function __ObtenerArreglosDoublePieVertical($arrReporte, $bolConservarColores = false) {
    $arrDatos      = $this->__ArreglarDatosGrafica($arrReporte);
    $arrCategorias = $arrDatos["Categorias"];
    $arrValores    = $arrDatos["Valores"   ];
    
    $strSeries1 = "[";
    $strSeries2 = "[";
    
    if(is_array($this->arrInfoGrafica)) {
      $arrInfoG = $this->arrInfoGrafica;
    } else {
      $arrInfoG = $this->arrInfoReporte;
    }
    
    // Empezamos a recorrer los datos
    $arrIndices = reset($arrValores);
    $i = 0;
    foreach($arrIndices as $strNombreCol => $arrInfoCol) {
      $i++;
      // Necesitamos al final el total, por lo que lo revertimos a cero
      $fltTotalCategoria = 0;
      
      // Calcular el color
      if($bolConservarColores) {
        if(isset($arrInfoG[$strNombreCol]["Color"]) && ($arrInfoG[$strNombreCol]["Color"] != "")) {
          $strColor = "'{$arrInfoG[$strNombreCol]["Color"]}'";
        } else {
          $strColor = "colors[$i % 10]";
        }
      } else {
        $strColor = "colors[$i % 10]";
      }
      
      // Recorremos cada uno de los datos de esa categoria
      foreach($arrCategorias as $intIndiceCat => $strNombreCat) {
        $strSeries2 .= "{";
        $strSeries2 .= "name:'$strNombreCat', ";
        $strSeries2 .= "color: $strColor, ";
        $strSeries2 .= "y: " . ($arrValores[$intIndiceCat][$strNombreCol]["Valor"] - 0);
        $strSeries2 .= "}, ";
        
        $fltTotalCategoria += $arrValores[$intIndiceCat][$strNombreCol]["Valor"];
      }
      
      $strSeries1 .= "{";
      $strSeries1 .= "name:'{$arrInfoCol["Nombre"]}', ";
      $strSeries1 .= "color: $strColor, ";
      $strSeries1 .= "y: $fltTotalCategoria";
      $strSeries1 .= "}, ";
    }
    
    $strSeries1 = substr($strSeries1, 0, -2) . "]";
    $strSeries2 = substr($strSeries2, 0, -2) . "]";
    
    return array("Series1" => $strSeries1, "Series2" => $strSeries2);
  }
  
  /**
   * Obtiene una grafica de Columnas Estacadas
   * 
   * @param array  $arrReporte     Arreglo con la informacion del reporte (Los datos a graficar)
   * @param string $strTipoOrden   Tipo del orden de los datos ("H" para Horizontal, "V" para Vertical)
   * @param string $strTipoGrafica Tipo de grafica que se creara ("stacked_column", "spline")
   * @return type
   */
  function __OGStackedColumn($arrReporte, $strTipoOrden = "H", $strTipoGrafica = "stacked_column") {
    if($strTipoOrden == "V") {
      $arrDatos      = $this->__ObtenerArreglosVertical  ($arrReporte);
    } else {
      $arrDatos      = $this->__ObtenerArreglosHorizontal($arrReporte);
    }
    
    $strCategorias = $arrDatos["Categorias"];
    $strSeries     = $arrDatos["Series"    ];
    
    // Ahora mandar llamar a la funcion que grafica
    $strRes = $this->__ObtenerLlamadaGraficacion($strTipoGrafica, $strSeries, $strCategorias, $this->strNombreReporte);
    
    return $strRes;
  }
  
  function __OGDoublePie($arrReporte, $strTipoOrden = "H", $bolConservarColores = false) {
    if($strTipoOrden == "H") {
      $arrDatos = $this->__ObtenerArreglosDoublePieHorizontal($arrReporte, $bolConservarColores);
    } else {
      $arrDatos = $this->__ObtenerArreglosDoublePieVertical  ($arrReporte, $bolConservarColores);
    }
    $strSeries1 = $arrDatos["Series1"];
    $strSeries2 = $arrDatos["Series2"];
    
    // Ahora mandar llamar a la funcion que grafica
    $strRes = $this->__ObtenerLlamadaGraficacion('double_pie', $strSeries1, $strSeries2, $this->strNombreReporte);
    
    return $strRes;
  }
  
  function __DefaultArregloInfo() {
    return "";
  }
  
  function __DefaultDifHeader() {
    return "";
  }
  
  function __DefaultDifColors() {
    return "";
  }
  
  function __DefaultConsultaIni() {
    Variables::DebugBacktrace("Para poder usar este metodo automaticamente, debe de proporcionar el codigo para esta funcion");
  }
  
  function InitDefaults($strNombreReporte = "", $strOpAgrupar = "") {
    $this->strAnchoDiv         = "100%";
    $this->strAltoDiv          = "700px";
    
    $this->Inicializar($strNombreReporte, $this->__DefaultArregloInfo(), $this->__DefaultConsultaIni(), $strOpAgrupar, $this->__DefaultDifHeader(), $this->__DefaultDifColors());
    
    $this->bolAlternarConClase = true;
  }
  
  function DoDefaultManager() {
    switch(Variables::GetOption('__OGTipoRep')) {
      case 'grafica':
        global $strTemplate;
        $strTemplate = "vacia.tpl.php";
        return $this->ObtenerGrafica();
      case 'excel':
        return $this->DoReporte   ($this->strOpAgrupar != "", true);
      case 'pdf':
        return $this->DoReportePDF($this->strOpAgrupar != "");
      default:
        return $this->DoReporte   ($this->strOpAgrupar != "", false);
    }
//    prent_r($_POST);
  }
  
  /**
   * Función que genera el reporte.
   *
   * Si se le pasa el parametro $bolEnExcel, se mandará al navegador el archivo
   * EXCEL del reporte para ser descargado, de otra manera se regresará una
   * cadena con la tabla HTML del reporte.
   * 
   * Los tipos de grafica posibles por el momento son:
   * 
   * stacked_column   => Columna de barras
   * stacked_column_v => Columna de barras (Datos verticales)
   * double_pie       => Doble PIE
   *
   * @param string  $strTipoGrafica           Tipo de grafica a mostrar con los datos
   * 
   * @return String Codigo JS de la grafica pedida.
   */
  function ObtenerGrafica($strTipoGrafica = "stacked_column") {
    $arrReporte = $this->__ArreglarDatosPrevioGrafica ();
    
    // Al hacer una grafica, se necesita incluir el codigo para HighCharts
    Template::AgregarArchivoExtra_S("highcharts/highcharts.js", "js");
    Template::AgregarArchivoExtra_S("codigo_graficas.js", "js");
    
    // Cada una de las graficas manda llamar una funcion diferente, porque cada una es tratada distinto
    switch($strTipoGrafica) {
      case "stacked_column":
        $strPagina = $this->__OGStackedColumn($arrReporte, "H");
        break;
      
      case "stacked_column_v":
        $strPagina = $this->__OGStackedColumn($arrReporte, "V");
        break;
      
      case "stacked_area":
        $strPagina = $this->__OGStackedColumn($arrReporte, "H", "stacked_area");
        break;
      
      case "stacked_area_v":
        $strPagina = $this->__OGStackedColumn($arrReporte, "V", "stacked_area");
        break;
      
      case "spline":
        $strPagina = $this->__OGStackedColumn($arrReporte, "H", "spline");
        break;
      
      case "spline_v":
        $strPagina = $this->__OGStackedColumn($arrReporte, "V", "spline");
        break;
      
      case "double_pie":
        $strPagina = $this->__OGDoublePie($arrReporte, "H");
        break;
      
      case "double_pie_v":
        $strPagina = $this->__OGDoublePie($arrReporte, "V");
        break;
      
      case "double_pie_color":
        $strPagina = $this->__OGDoublePie($arrReporte, "H", true);
        break;
      
      case "double_pie_color_v":
        $strPagina = $this->__OGDoublePie($arrReporte, "V", true);
        break;
      
      default:
        $strPagina = "<h1>No se puede recrear el codigo para el tipo de grafica $strTipoGrafica</h1>";
        break;
    }
    
    return $strPagina;
  }
}

?>